home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / sun4.md / netIE.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  24KB  |  863 lines
  1. /* 
  2.  * netIE.c --
  3.  *
  4.  *    The main routines for the device driver for the Intel 82586 Ethernet 
  5.  *    Controller.
  6.  *
  7.  *      This chip has several pecularities that have to be compensated for
  8.  *      when using it.  First of all no element of the scatter-gather
  9.  *      array which is passed into the output routine can be below a
  10.  *      minimum size.  The minimum size is defined in the file netIEXmit.c
  11.  *      and is called MIN_XMIT_BUFFER_SIZE.  Secondly none of the
  12.  *      scatter-gather elements can begin on an odd boundary.  If they do,
  13.  *      the chip drops the low order bit and sends one more byte than was
  14.  *      specified.  There are warnings printed in each of these cases.
  15.  *
  16.  * TODO: Watch dogs to make sure that the chip does not get stuck.  Rumor has
  17.  *     it that because of bugs in the chip it can get stuck at any time for
  18.  *     no particular reason.
  19.  *
  20.  * Copyright 1985, 1988 Regents of the University of California
  21.  * Permission to use, copy, modify, and distribute this
  22.  * software and its documentation for any purpose and without
  23.  * fee is hereby granted, provided that the above copyright
  24.  * notice appear in all copies.  The University of California
  25.  * makes no representations about the suitability of this
  26.  * software for any purpose.  It is provided "as is" without
  27.  * express or implied warranty.
  28.  *
  29.  */
  30.  
  31. #ifndef lint
  32. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/net/sun4.md/netIE.c,v 9.7 92/04/14 16:57:48 jhh Exp $ SPRITE (Berkeley)";
  33. #endif
  34.  
  35. #include <sprite.h>
  36. #include <sys.h>
  37. #include <list.h>
  38. #include <netIEInt.h>
  39. #include <vm.h>
  40. #include <vmMach.h>
  41. #include <mach.h>
  42. #include <machMon.h>
  43. #include <assert.h>
  44.  
  45. static Net_EtherAddress BROADCAST_ADDR = {0xab,0x00,0x00,0x01,0x00,0x00};
  46.  
  47. /*
  48.  *----------------------------------------------------------------------
  49.  *
  50.  * NetIEInit --
  51.  *
  52.  *    Initialize the Intel Ethernet chip.
  53.  *
  54.  * Results:
  55.  *    SUCCESS if the Intel controller was found and initialized,
  56.  *    FAILURE otherwise.
  57.  *
  58.  * Side effects:
  59.  *    Initializes the chip.
  60.  *
  61.  *----------------------------------------------------------------------
  62.  */
  63.  
  64. ReturnStatus
  65. NetIEInit(interPtr)
  66.     Net_Interface    *interPtr;     /* Network interface. */
  67. {
  68.     Address     ctrlAddr;    /* Kernel virtual address of controller. */
  69.     int     i;
  70.     List_Links    *itemPtr;
  71.     NetIEState    *statePtr;
  72.     ReturnStatus     status;
  73.  
  74.     DISABLE_INTR();
  75.  
  76.     /*
  77.      * Check that our structures are the correct size.  Some of the sizes
  78.      * are different on the sun4 due to padding and alignment, but that
  79.      * has been taken into account.
  80.      */
  81. #ifdef sun4
  82.     assert(sizeof(NetIESysConfPtr) == 12);
  83.     assert(sizeof(NetIERecvFrameDesc) == 28);
  84.     assert(sizeof(NetIERecvBufDesc) == 20);
  85. #else
  86.     assert(sizeof(NetIESysConfPtr) == 10);
  87.     assert(sizeof(NetIERecvFrameDesc) == 26);
  88.     assert(sizeof(NetIERecvBufDesc) == 18);
  89. #endif
  90.     assert(sizeof(NetIEIntSysConfPtr) == 8);
  91.     assert(sizeof(NetIESCBStatus) == 2);
  92.     assert(sizeof(NetIESCBCommand) == 2);
  93.     assert(sizeof(NetIESCB) == 16);
  94.     assert(sizeof(NetIECommandBlock) == 6);
  95.     assert(sizeof(NetIENOPCB) == 6);
  96.     assert(sizeof(NetIEIASetupCB) == 12);
  97.     assert(sizeof(NetIEConfigureCB) == 18);
  98.     assert(sizeof(NetIETransmitCB) == 16);
  99.     assert(sizeof(NetIETransmitBufDesc) == 8);
  100.     assert(sizeof(NetIEControlRegister) == 1);
  101.  
  102.  
  103.     ctrlAddr = interPtr->ctrlAddr;
  104.     /*
  105.      * If the address is physical (not in kernel's virtual address space)
  106.      * then we have to map it in.
  107.      */
  108.     if (interPtr->virtual == FALSE) {
  109.     ctrlAddr = (Address) VmMach_MapInDevice(ctrlAddr, 1);
  110.     }
  111.     statePtr = (NetIEState *) malloc (sizeof(NetIEState));
  112.     bzero((char *) statePtr, sizeof(NetIEState));
  113.  
  114.     statePtr->running = FALSE;
  115.  
  116.     /*
  117.      * The onboard control register is at a pre-defined kernel virtual
  118.      * address.  The virtual mapping is set up by the sun PROM monitor
  119.      * and passed to us from the netInterface table.
  120.      */
  121.  
  122.     statePtr->controlReg = 
  123.     (volatile NetIEControlRegister *) ctrlAddr;
  124.  
  125.      {
  126.     /*
  127.      * Poke the controller by resetting it.
  128.      */
  129.     char zero = 0;
  130.     ReturnStatus status;
  131.  
  132.     status = Mach_Probe(sizeof(char), &zero,
  133.         (char *)statePtr->controlReg);
  134.     if (status != SUCCESS) {
  135.         /*
  136.          * Got a bus error.
  137.          */
  138.         free((char *) statePtr);
  139.         ENABLE_INTR();
  140.         return(FAILURE);
  141.     }
  142.     }
  143.     Mach_SetHandler(interPtr->vector, Net_Intr, (ClientData) interPtr);
  144.     /*
  145.      * Initialize the transmission list.  
  146.      */
  147.  
  148.     statePtr->xmitList = &statePtr->xmitListHdr;
  149.     List_Init(statePtr->xmitList);
  150.  
  151.     statePtr->xmitFreeList = &statePtr->xmitFreeListHdr;
  152.     List_Init(statePtr->xmitFreeList);
  153.  
  154.     netIEXmitFiller = (char *)VmMach_NetMemAlloc(NET_ETHER_MIN_BYTES);
  155.     statePtr->netIEXmitTempBuffer = 
  156.         (char *)VmMach_NetMemAlloc(NET_ETHER_MAX_BYTES + 2);
  157.  
  158.     for (i = 0; i < NET_IE_NUM_XMIT_ELEMENTS; i++) {
  159.     itemPtr = (List_Links *) VmMach_NetMemAlloc(sizeof(NetXmitElement)), 
  160.     List_InitElement(itemPtr);
  161.     List_Insert(itemPtr, LIST_ATREAR(statePtr->xmitFreeList));
  162.     }
  163.  
  164.     /*
  165.      * Get ethernet address out of the rom.  It is stored in a normal order
  166.      * even though the chip is wired backwards because fortunately the chip
  167.      * stores the ethernet address backwards from how we store it.  Therefore
  168.      * two backwards makes one forwards, right?
  169.      */
  170.  
  171.     Mach_GetEtherAddress(&statePtr->etherAddress);
  172.     printf("%s Ethernet address %x:%x:%x:%x:%x:%x\n", 
  173.           interPtr->name,
  174.           statePtr->etherAddress.byte1 & 0xff,
  175.           statePtr->etherAddress.byte2 & 0xff,
  176.           statePtr->etherAddress.byte3 & 0xff,
  177.           statePtr->etherAddress.byte4 & 0xff,
  178.           statePtr->etherAddress.byte5 & 0xff,
  179.           statePtr->etherAddress.byte6 & 0xff);
  180.     /*
  181.      * Allocate space for the System Configuration Pointer.
  182.      */
  183.  
  184.     VmMach_MapIntelPage((Address) (NET_IE_SYS_CONF_PTR_ADDR));
  185.     statePtr->sysConfPtr = (NetIESysConfPtr *) NET_IE_SYS_CONF_PTR_ADDR;
  186.  
  187.     /*
  188.      * Allocate space for all of the receive buffers. The buffers are 
  189.      * allocated on an odd short word boundry so that packet data (after
  190.      * the ethernet header) will start on a long word boundry. This 
  191.      * eliminates unaligned word fetches from the RPC module which would
  192.      * cause alignment traps on SPARC processors such as the sun4.
  193.      */ 
  194.  
  195. #define    ALIGNMENT_PADDING    (sizeof(Net_EtherHdr)&0x3)
  196.     for (i = 0; i < NET_IE_NUM_RECV_BUFFERS; i++) {
  197.     statePtr->netIERecvBuffers[i] = 
  198.         VmMach_NetMemAlloc(NET_IE_RECV_BUFFER_SIZE + ALIGNMENT_PADDING)
  199.             + ALIGNMENT_PADDING;
  200.     }
  201. #undef ALIGNMENT_PADDING
  202.  
  203.     interPtr->init    = NetIEInit;
  204.     interPtr->output     = NetIEOutput;
  205.     interPtr->intr    = NetIEIntr;
  206.     interPtr->ioctl    = NetIEIOControl;
  207.     interPtr->reset     = NetIERestart;
  208.     interPtr->getStats    = NetIEGetStats;
  209.     interPtr->netType    = NET_NETWORK_ETHER;
  210.     interPtr->maxBytes    = NET_ETHER_MAX_BYTES - sizeof(Net_EtherHdr);
  211.     interPtr->minBytes    = 0;
  212.     interPtr->interfaceData = (ClientData) statePtr;
  213.     status = Net_SetAddress(NET_ADDRESS_ETHER, 
  214.         (Address) &statePtr->etherAddress,
  215.         &interPtr->netAddress[NET_PROTO_RAW]);
  216.     if (status != SUCCESS) {
  217.     panic("NetIEInit: Net_SetAddress failed\n");
  218.     }
  219.     interPtr->broadcastAddress = netEtherBroadcastAddress;
  220.     interPtr->flags |= NET_IFLAGS_BROADCAST;
  221.     statePtr->interPtr = interPtr;
  222.  
  223.     /*
  224.      * Reset the world.
  225.      */
  226.  
  227.     NetIEReset(interPtr);
  228.  
  229.     /*
  230.      * Unmap the extra page.
  231.      */
  232.  
  233.     VmMach_UnmapIntelPage((Address) (NET_IE_SYS_CONF_PTR_ADDR));
  234.  
  235.     /*
  236.      * Now we are running.
  237.      */
  238.  
  239.     statePtr->running     = TRUE;
  240.     ENABLE_INTR();
  241.     return (SUCCESS);
  242. }
  243.  
  244.  
  245. /*
  246.  *----------------------------------------------------------------------
  247.  *
  248.  * NetIEDefaultConfig --
  249.  *
  250.  *    Set up the default configuration for the intel chip as specified
  251.  *    in the intel manual.  The only difference from the Intel manual
  252.  *    is the fifo length.
  253.  *
  254.  * Results:
  255.  *    None.
  256.  *
  257.  * Side effects:
  258.  *    The global command block is modified.
  259.  *
  260.  *----------------------------------------------------------------------
  261.  */
  262.  
  263. void
  264. NetIEDefaultConfig(statePtr)
  265.     NetIEState        *statePtr;
  266. {
  267.     NetIEConfigureCB    *confCBPtr;
  268.  
  269.     confCBPtr = (NetIEConfigureCB *) statePtr->cmdBlockPtr;
  270.     bzero((Address) confCBPtr, sizeof(NetIEConfigureCB));
  271.     NetBfShortSet(confCBPtr->cmdBlock.bits, CmdNumber, NET_IE_CONFIG);
  272.     NetBfShortSet(confCBPtr->bits, ByteCount, 12);
  273.     NetBfShortSet(confCBPtr->bits, FifoLimit, 12);
  274.     NetBfShortSet(confCBPtr->bits, Preamble, 2);
  275.     NetBfShortSet(confCBPtr->bits, AddrLen, 6);
  276.     NetBfShortSet(confCBPtr->bits, AtLoc, 0);
  277.     NetBfShortSet(confCBPtr->bits, InterFrameSpace, 96);
  278.     NetBfShortSet(confCBPtr->bits, SlotTimeHigh , 512 >> 8);
  279.     NetBfShortSet(confCBPtr->bits, MinFrameLength, 64);
  280.     NetBfShortSet(confCBPtr->bits, NumRetries, 15);
  281.  
  282. /*
  283.     confCBPtr->intLoopback = 1;
  284. */
  285.  
  286.     NetIEExecCommand((NetIECommandBlock *) confCBPtr, statePtr);
  287.     return;
  288. }
  289.  
  290.  
  291. /*
  292.  *----------------------------------------------------------------------
  293.  *
  294.  * NetIEReset --
  295.  *
  296.  *    Reset the interface.
  297.  *
  298.  * Results:
  299.  *    None.
  300.  *
  301.  * Side effects:
  302.  *    All of the pointers in the interface structure are initialized.
  303.  *
  304.  *----------------------------------------------------------------------
  305.  */
  306.  
  307. void
  308. NetIEReset(interPtr)
  309.     Net_Interface    *interPtr;     /* Interface to reset. */
  310. {
  311.     NetIEIASetupCB            *addressCommandPtr;
  312.     NetIEMASetupCB            *addressMACommandPtr;
  313.     volatile NetIECommandBlock    *diagCmdPtr;
  314.     NetIEState            *statePtr;
  315.  
  316.     /*
  317.      * Nil out all pointers.
  318.      */
  319.     statePtr = (NetIEState *) interPtr->interfaceData;
  320.     statePtr->intSysConfPtr = (NetIEIntSysConfPtr *) NIL;
  321.     statePtr->scbPtr = (NetIESCB *) NIL;
  322.     statePtr->recvFrDscHeadPtr = (NetIERecvFrameDesc *) NIL;
  323.     statePtr->recvFrDscTailPtr = (NetIERecvFrameDesc *) NIL;
  324.     statePtr->recvBufDscHeadPtr = (NetIERecvBufDesc *) NIL;
  325.     statePtr->recvBufDscTailPtr = (NetIERecvBufDesc *) NIL;
  326.  
  327.     /* 
  328.      * Reset the chip.
  329.      */
  330.  
  331.     NET_IE_CHIP_RESET(statePtr);
  332.  
  333.     /*
  334.      * Initialize memory.
  335.      */
  336.  
  337.     NetIEMemInit(statePtr);
  338.  
  339.     /*
  340.      * Allocate the system intermediate configuration pointer and the 
  341.      * system control block.
  342.      */
  343.  
  344.     statePtr->intSysConfPtr = (NetIEIntSysConfPtr *) NetIEMemAlloc(statePtr);
  345.     if (statePtr->intSysConfPtr == (NetIEIntSysConfPtr *) NIL) {
  346.     panic("Intel: No memory for the scp.\n");
  347.     }
  348.  
  349.     statePtr->scbPtr = (NetIESCB *) NetIEMemAlloc(statePtr);
  350.     if (statePtr->scbPtr == (NetIESCB *) NIL) {
  351.     panic("Intel: No memory for the scb.\n");
  352.     }
  353.  
  354.  
  355.     while (TRUE) {
  356.     /*
  357.      * Initialize the system configuration pointer.
  358.      */
  359.  
  360.     bzero((Address) statePtr->sysConfPtr, sizeof(NetIESysConfPtr));
  361.     statePtr->sysConfPtr->intSysConfPtr = 
  362.             NetIEAddrFromSUNAddr((int) statePtr->intSysConfPtr);
  363.  
  364.     /* 
  365.      * Initialize the intermediate system configuration pointer.
  366.      */
  367.  
  368.     bzero((Address) statePtr->intSysConfPtr, sizeof(NetIEIntSysConfPtr));
  369.     statePtr->intSysConfPtr->busy = 1;
  370.     statePtr->intSysConfPtr->base = 
  371.                 NetIEAddrFromSUNAddr((int) statePtr->memBase);
  372.     statePtr->intSysConfPtr->scbOffset = 
  373.                 NetIEOffsetFromSUNAddr((int) statePtr->scbPtr,
  374.                     statePtr);
  375.  
  376.     /*
  377.      * Initialize the system control block.
  378.      */
  379.  
  380.     bzero((Address) statePtr->scbPtr, sizeof(NetIESCB));
  381.  
  382.     /*
  383.      * Turn off the reset bit.
  384.      */
  385.  
  386.     NetBfByteSet(statePtr->controlReg, NoReset, 1);
  387.     MACH_DELAY(200);
  388.  
  389.     /* 
  390.      * Get the attention of the chip so that it will initialize itself.
  391.      */
  392.  
  393.     NET_IE_CHANNEL_ATTENTION(statePtr);
  394.  
  395.     /* 
  396.      * Ensure that that the chip gets the intermediate initialization
  397.      * stuff and that the scb is updated.
  398.      */
  399.     
  400.     NET_IE_DELAY(!statePtr->intSysConfPtr->busy);
  401.     NET_IE_DELAY(NetBfShortTest(statePtr->scbPtr->statusWord, 
  402.         CmdUnitNotActive, 1));
  403.  
  404.     /*
  405.      * Wait for an interrupt.
  406.      */
  407.  
  408.     NET_IE_DELAY(NetBfByteTest(statePtr->controlReg, IntrPending, 1));
  409.  
  410.     /*
  411.      * Make sure that the chip was initialized properly.
  412.      */
  413.  
  414.     if (statePtr->intSysConfPtr->busy || 
  415.         NetBfShortTest(statePtr->scbPtr->statusWord, CmdUnitNotActive, 0) ||
  416.         NetBfByteTest(statePtr->controlReg, IntrPending, 0)) {
  417.  
  418.         printf("Warning: Could not initialize Intel chip.\n");
  419.     }
  420.     if (NetBfShortTest(statePtr->scbPtr->statusWord, CmdUnitStatus, 
  421.         NET_IE_CUS_IDLE)) {
  422.         break;
  423.     }
  424.  
  425.     printf("Warning: Intel cus not idle after reset\n");
  426.     NET_IE_CHIP_RESET(statePtr);
  427.     }
  428.  
  429.     /*
  430.      * Allocate a single command block to be used by all commands.
  431.      */
  432.  
  433.     statePtr->cmdBlockPtr = (NetIECommandBlock *) NetIEMemAlloc(statePtr);
  434.     if (statePtr->cmdBlockPtr == (NetIECommandBlock *) NIL) {
  435.     panic("NetIE: No memory for the command block.\n");
  436.     }
  437.     statePtr->scbPtr->cmdListOffset =
  438.             NetIEOffsetFromSUNAddr((int) statePtr->cmdBlockPtr,
  439.                 statePtr);
  440.  
  441.     /*
  442.      * Do a diagnose command on the interface.
  443.      */
  444.  
  445.     diagCmdPtr = statePtr->cmdBlockPtr;
  446.     bzero((Address) diagCmdPtr, sizeof(*diagCmdPtr));
  447.     NetBfShortSet(diagCmdPtr->bits, CmdNumber,  NET_IE_DIAGNOSE);
  448.     NetIEExecCommand(diagCmdPtr, statePtr);
  449.     if (NetBfShortTest(diagCmdPtr->bits, CmdOK, 0)) {
  450.     panic("Intel failed diagnostics.\n");
  451.     }
  452.  
  453.     /*
  454.      * Let the interface know its address.
  455.      */
  456.  
  457.     addressCommandPtr = (NetIEIASetupCB *) statePtr->cmdBlockPtr;
  458.     bzero((Address) addressCommandPtr, sizeof(NetIEIASetupCB));
  459.     NetBfShortSet(addressCommandPtr->cmdBlock.bits, CmdNumber, NET_IE_IA_SETUP);
  460.     addressCommandPtr->etherAddress = statePtr->etherAddress;
  461.     NetIEExecCommand((NetIECommandBlock *) addressCommandPtr, statePtr);
  462.  
  463.     /*
  464.      * Set the boot multicast address.
  465.      */
  466.  
  467.     addressMACommandPtr = (NetIEMASetupCB *) statePtr->cmdBlockPtr;
  468.     bzero((Address) addressCommandPtr, sizeof(NetIEMASetupCB));
  469.     NetBfShortSet(addressCommandPtr->cmdBlock.bits, CmdNumber, NET_IE_MC_SETUP);
  470.     addressMACommandPtr->count = 1;
  471.     addressMACommandPtr->etherAddress = BROADCAST_ADDR;
  472.     NetIEExecCommand((NetIECommandBlock *) addressMACommandPtr, statePtr);
  473.  
  474.     /*
  475.      * Set up the default configuration values.
  476.      */
  477.  
  478.     NetIEDefaultConfig(statePtr);
  479.  
  480.     /*
  481.      * Set up the receive queues.
  482.      */
  483.  
  484.     NetIERecvUnitInit(statePtr);
  485.  
  486.     /*
  487.      * Enable interrupts and get out of loop back mode.  Make sure that don't
  488.      * get out of loop back mode before because the Intel is supposed to
  489.      * be unpredictable until we initialize things.
  490.      */
  491.  
  492.     NetBfByteSet(statePtr->controlReg, IntrEnable, 1);
  493.     NetBfByteSet(statePtr->controlReg, NoLoopback, 1);
  494.  
  495.     /*
  496.      * Initialize the transmit queues and start transmitting if anything ready
  497.      * to tranmit.
  498.      */
  499.  
  500.     NetIEXmitInit(statePtr);
  501.     interPtr->flags |= NET_IFLAGS_RUNNING;
  502.     return;
  503. }
  504.  
  505.  
  506. /*
  507.  *----------------------------------------------------------------------
  508.  *
  509.  * NetIERestart --
  510.  *
  511.  *    Reinitialize the Intel Ethernet chip.
  512.  *
  513.  * Results:
  514.  *    None.
  515.  *
  516.  * Side effects:
  517.  *    None.
  518.  *
  519.  *----------------------------------------------------------------------
  520.  */
  521. void
  522. NetIERestart(interPtr)
  523.     Net_Interface    *interPtr;     /* Interface to restart. */
  524. {
  525.     NetIEState    *statePtr = (NetIEState *) interPtr->interfaceData;
  526.  
  527.     DISABLE_INTR();
  528.  
  529.     /*
  530.      * Drop the current packet so the transmitting process doesn't hang.
  531.      */
  532.     NetIEXmitDrop(statePtr);
  533.  
  534.     /*
  535.      * Allocate space for the System Configuration Pointer.
  536.      */
  537.     VmMach_MapIntelPage((Address) (NET_IE_SYS_CONF_PTR_ADDR));
  538.  
  539.     /*
  540.      * Reset the world.
  541.      */
  542.     NetIEReset(interPtr);
  543.  
  544.     /*
  545.      * Unmap the extra page.
  546.      */
  547.     VmMach_UnmapIntelPage((Address) (NET_IE_SYS_CONF_PTR_ADDR));
  548.  
  549.     ENABLE_INTR();
  550.     return;
  551. }
  552.  
  553.  
  554. /*
  555.  *----------------------------------------------------------------------
  556.  *
  557.  * NetIEIntr --
  558.  *
  559.  *    Process an interrupt from the Intel chip.
  560.  *
  561.  * Results:
  562.  *    None.
  563.  *
  564.  * Side effects:
  565.  *    None.
  566.  *
  567.  *----------------------------------------------------------------------
  568.  */
  569. void
  570. NetIEIntr(interPtr, polling)
  571.     Net_Interface    *interPtr;    /* Interface to process. */
  572.     Boolean        polling;    /* TRUE if are being polled instead of
  573.                      * processing an interrupt. */
  574. {
  575.     register    NetIEState    *statePtr;
  576.     volatile register NetIESCB    *scbPtr;
  577.     register    int        status;
  578.  
  579.     statePtr = (NetIEState *) interPtr->interfaceData;
  580.     scbPtr = statePtr->scbPtr;
  581.     /*
  582.      * If we got a bus error then panic.
  583.      */
  584.     if (NetBfByteTest(statePtr->controlReg, BusError, 1)) {
  585.     printf("Warning: Intel: Bus error on chip.\n");
  586.     NetIERestart(interPtr);
  587.     return;
  588.     }
  589.  
  590.     /*
  591.      * If interrupts aren't enabled or there is no interrupt pending, then
  592.      * what are we doing here?
  593.      */
  594.     if (!(NetBfByteTest(statePtr->controlReg, IntrEnable, 1) && 
  595.     NetBfByteTest(statePtr->controlReg, IntrPending, 1))) {
  596.     /*
  597.      * I'm not sure why this is commented out. That's the way I found
  598.      * it.  JHH
  599.      */
  600. #if 0
  601.     if (!polling) {
  602.         printf("Intel: Spurious interrupt <%x>\n", 
  603.         (unsigned int) (*((unsigned char *) statePtr->controlReg)));
  604.     }
  605.     return;
  606. #endif 
  607.     } 
  608.  
  609.     status = NET_IE_CHECK_STATUS(scbPtr->statusWord);
  610.     if (status == 0) {
  611.     if (!polling) {
  612.         printf("Intel: Spurious interrupt (2)\n");
  613.     }
  614.     return;
  615.     }
  616.  
  617.     /*
  618.      * Go ahead and ack the events that got us here.
  619.      */
  620.     NET_IE_CHECK_SCB_CMD_ACCEPT(scbPtr);
  621.     NET_IE_ACK(scbPtr->cmdWord[0], status);
  622.     NET_IE_CHANNEL_ATTENTION(statePtr);
  623.  
  624.     /*
  625.      * If we got a packet, then process it.
  626.      */
  627.     if (NET_IE_RECEIVED(status)) {
  628.     NetIERecvProcess(FALSE, statePtr);
  629.     }
  630.  
  631.     /*
  632.      * If a transmit command completed then process it.
  633.      */
  634.     if (NET_IE_TRANSMITTED(status)) {
  635.     NetIEXmitDone(statePtr);
  636.     }
  637.     return;
  638. }
  639.  
  640.  
  641.  
  642. /*
  643.  *----------------------------------------------------------------------
  644.  *
  645.  * NetIEGetStats --
  646.  *
  647.  *    Return the statistics for the interface.
  648.  *
  649.  * Results:
  650.  *    A pointer to the statistics structure.
  651.  *
  652.  * Side effects:
  653.  *    None.
  654.  *
  655.  *----------------------------------------------------------------------
  656.  */
  657.  
  658. ReturnStatus
  659. NetIEGetStats(interPtr, statPtr)
  660.     Net_Interface    *interPtr;        /* Current interface. */
  661.     Net_Stats        *statPtr;        /* Statistics to return. */
  662. {
  663.     NetIEState    *statePtr;
  664.     statePtr = (NetIEState *) interPtr->interfaceData;
  665.     DISABLE_INTR();
  666.     statPtr->ether = statePtr->stats;
  667.     ENABLE_INTR();
  668.     return SUCCESS;
  669. }
  670.  
  671. /*
  672.  *----------------------------------------------------------------------
  673.  *
  674.  * NetIEIOControl --
  675.  *
  676.  *    Perform ioctls for the adapter.  Right now we don't support any.
  677.  *
  678.  * Results:
  679.  *    DEV_INVALID_ARG
  680.  *
  681.  * Side effects:
  682.  *    None.
  683.  *
  684.  *----------------------------------------------------------------------
  685.  */
  686.  
  687. /*ARGSUSED*/
  688. ReturnStatus
  689. NetIEIOControl(interPtr, ioctlPtr, replyPtr)
  690.     Net_Interface *interPtr;    /* Interface on which to perform ioctl. */
  691.     Fs_IOCParam *ioctlPtr;    /* Standard I/O Control parameter block */
  692.     Fs_IOReply *replyPtr;    /* Size of outBuffer and returned signal */
  693. {
  694.     return DEV_INVALID_ARG;
  695. }
  696.  
  697. /*
  698.  *----------------------------------------------------------------------
  699.  *
  700.  * NetIEStatePrint --
  701.  *
  702.  *    Prints out the contents of a NetIEState..
  703.  *
  704.  * Results:
  705.  *    None.
  706.  *
  707.  * Side effects:
  708.  *    Stuff is printed.
  709.  *
  710.  *----------------------------------------------------------------------
  711.  */
  712.  
  713. void
  714. NetIEStatePrint(statePtr)
  715.     NetIEState        *statePtr;
  716. {
  717.     printf("statePtr = 0x%x\n", statePtr);
  718.     printf("membase = 0x%x\n", statePtr->memBase);
  719.     printf("sysConfPtr = 0x%x\n", statePtr->sysConfPtr);
  720.     printf("intSysConfPtr = 0x%x\n", statePtr->intSysConfPtr);
  721.     printf("scbPtr = 0x%x\n", statePtr->scbPtr);
  722.     printf("cmdBlockPtr = 0x%x\n", statePtr->cmdBlockPtr);
  723.     printf("recvFrDscHeadPtr = 0x%x\n", statePtr->recvFrDscHeadPtr);
  724.     printf("recvFrDscTailPtr = 0x%x\n", statePtr->recvFrDscTailPtr);
  725.     printf("recvBufDscHeadPtr = 0x%x\n", statePtr->recvBufDscHeadPtr);
  726.     printf("recvBufDscTailPtr = 0x%x\n", statePtr->recvBufDscTailPtr);
  727.     printf("xmitList = 0x%x\n", statePtr->xmitList);
  728.     printf("xmitFreeList = 0x%x\n", statePtr->xmitFreeList);
  729.     printf("xmitCBPtr = 0x%x\n", statePtr->xmitCBPtr);
  730.     printf("transmitting = %d\n", statePtr->transmitting);
  731.     printf("running = %d\n", statePtr->running);
  732.     printf("controlReg = 0x%x\n", statePtr->controlReg);
  733.     printf("netIEXmitTempBuffer = 0x%x\n", statePtr->netIEXmitTempBuffer);
  734.     printf("xmitBufAddr = 0x%x\n", statePtr->xmitBufAddr);
  735.     printf("curScatGathPtr = 0x%x\n", statePtr->curScatGathPtr);
  736.     printf("interPtr = 0x%x\n", statePtr->interPtr);
  737. }
  738.  
  739. /*
  740.  *----------------------------------------------------------------------
  741.  *
  742.  * NetIEIntSysConfPtrPrint --
  743.  *
  744.  *    Prints the contents of a NetIEIntSysConfPtr.
  745.  *
  746.  * Results:
  747.  *    None.
  748.  *
  749.  * Side effects:
  750.  *    Stuff is printed
  751.  *
  752.  *----------------------------------------------------------------------
  753.  */
  754.  
  755. void
  756. NetIEIntSysConfPtrPrint(confPtr) 
  757.     volatile NetIEIntSysConfPtr    *confPtr;
  758. {
  759.     printf("busy = %d\n", (int) confPtr->busy);
  760.     printf("scbOffset = 0x%x\n",  confPtr->scbOffset);
  761.     printf("base = 0x%x\n", confPtr->base); 
  762. }
  763.  
  764. /*
  765.  *----------------------------------------------------------------------
  766.  *
  767.  * NetIESCBPrint --
  768.  *
  769.  *    description.
  770.  *
  771.  * Results:
  772.  *    None.
  773.  *
  774.  * Side effects:
  775.  *    None.
  776.  *
  777.  *----------------------------------------------------------------------
  778.  */
  779.  
  780. void
  781. NetIESCBPrint(scbPtr)
  782.     volatile NetIESCB    *scbPtr;
  783. {
  784.     printf("status = 0x%x\n", * ((unsigned short *) scbPtr->statusWord));
  785.     printf("cmd = 0x%x\n", * ((unsigned short *) scbPtr->cmdWord));
  786.     printf("cmdListOffset = 0x%x\n",  scbPtr->cmdListOffset);
  787.     printf("recvFrameAreaOffset = 0x%x\n",  scbPtr->recvFrameAreaOffset);
  788.     printf("crcErrors = %d\n",  scbPtr->crcErrors);
  789.     printf("alignErrors = %d\n",  scbPtr->alignErrors);
  790.     printf("resourceErrors = %d\n",  scbPtr->resourceErrors);
  791.     printf("overrunErrors = %d\n",  scbPtr->overrunErrors);
  792. }
  793.  
  794. /*
  795.  *----------------------------------------------------------------------
  796.  *
  797.  * NetIETransmitCBPrint --
  798.  *
  799.  *    Print the contents of a NetIETransmitCB.
  800.  *
  801.  * Results:
  802.  *    None.
  803.  *
  804.  * Side effects:
  805.  *    stuff is printed.
  806.  *
  807.  *----------------------------------------------------------------------
  808.  */
  809.  
  810. void
  811. NetIETransmitCBPrint(xmitCBPtr)
  812.     NetIETransmitCB    *xmitCBPtr;
  813. {
  814.     char buffer[32];
  815.     printf("xmitCBPtr = 0x%x\n", xmitCBPtr);
  816.     printf("bits = 0x%x\n", xmitCBPtr->bits[0]);
  817.     printf("nextCmdBlock = 0x%x\n", xmitCBPtr->nextCmdBlock);
  818.     printf("bufDescOffset = 0x%x\n", xmitCBPtr->bufDescOffset);
  819.     printf("etherAddress = %s\n", 
  820.     Net_EtherAddrToString(&xmitCBPtr->destEtherAddr, buffer));
  821.     printf("type = 0x%x\n", xmitCBPtr->type);
  822. }
  823.  
  824. void
  825. NetIERecvBufDescPrint(recvBufDescPtr)
  826.     NetIERecvBufDesc    *recvBufDescPtr;
  827. {
  828.     printf("recvBufDescPtr = 0x%x\n", recvBufDescPtr);
  829.     printf("bits1 = 0x%x\n", recvBufDescPtr->bits1[0]);
  830.     printf("nextRBD = 0x%x\n", recvBufDescPtr->nextRBD);
  831.     printf("bufAddr = 0x%x\n", recvBufDescPtr->bufAddr);
  832.     printf("bits2 = 0x%x\n", recvBufDescPtr->bits2[0]);
  833.     printf("realBufAddr = 0x%x\n", recvBufDescPtr->realBufAddr);
  834.     printf("realNextRBD = 0x%x\n", recvBufDescPtr->realNextRBD);
  835. }
  836.  
  837. void
  838. NetIERecvFrameDescPrint(recvFrDescPtr) 
  839.     NetIERecvFrameDesc     *recvFrDescPtr;
  840. {
  841.     char    buffer[32];
  842.     printf("NetIERecvFrameDesc = 0x%x\n", recvFrDescPtr);
  843.     printf("bits = 0x%x\n", recvFrDescPtr->bits[0]);
  844.     printf("nextRFD = 0x%x\n", recvFrDescPtr->nextRFD);
  845.     printf("recvBufferDesc = 0x%x\n", recvFrDescPtr->recvBufferDesc);
  846.     printf("destAddr = %s\n", 
  847.     Net_EtherAddrToString(&recvFrDescPtr->destAddr, buffer));
  848.     printf("srcAddr = %s\n", 
  849.     Net_EtherAddrToString(&recvFrDescPtr->srcAddr, buffer));
  850.     printf("type = 0x%x\n", recvFrDescPtr->type);
  851. }
  852.  
  853. void
  854. NetIETransmitBufDescPrint(xmitBufDescPtr)
  855.     NetIETransmitBufDesc    *xmitBufDescPtr;
  856. {
  857.     printf("xmitBufDescPtr = 0x%x\n", xmitBufDescPtr);
  858.     printf("bits = 0x%x\n", * (unsigned short *) xmitBufDescPtr);
  859.     printf("nextTBD = 0x%x\n", xmitBufDescPtr->nextTBD);
  860.     printf("bufAddr = 0x%x\n", xmitBufDescPtr->bufAddr);
  861. }
  862.  
  863.